///////////////////////////////////////////////////////////////////////////////
//
// DBT86 Project : x86 Platform : x86 Interpreter : opprotos.h
// Copyright (C) 2004 by Ben Hertzberg and Stanford University
// All Rights Reserved
//
// This code may not be used for any purpose without the express written
// consent of the author.  See the LICENSE.txt file for details.
//
//
// DESCRIPTION
//
// This header lists prototypes for all instructions on x86.
//
///////////////////////////////////////////////////////////////////////////////

#ifndef __OPPROTOS_H__
#define __OPPROTOS_H__

// from interp.cpp
void INVALIDOP();

// from alu.cpp
void ADD_Eb_Gb();
void ADD_Ew_Gw();
void ADD_Ed_Gd();
void ADD_Gb_Eb();
void ADD_Gw_Ew();
void ADD_Gd_Ed();
void ADD_AL_Ib();
void ADD_AX_Iw();
void ADD_EAX_Id();
void ADD_Eb_I();
void ADD_Ew_I();
void ADD_Ed_I();
void OR_Eb_Gb();
void OR_Ew_Gw();
void OR_Ed_Gd();
void OR_Gb_Eb();
void OR_Gw_Ew();
void OR_Gd_Ed();
void OR_AL_Ib();
void OR_AX_Iw();
void OR_EAX_Id();
void OR_Eb_I();
void OR_Ew_I();
void OR_Ed_I();
void ADC_Eb_Gb();
void ADC_Ew_Gw();
void ADC_Ed_Gd();
void ADC_Gb_Eb();
void ADC_Gw_Ew();
void ADC_Gd_Ed();
void ADC_AL_Ib();
void ADC_AX_Iw();
void ADC_EAX_Id();
void ADC_Eb_I();
void ADC_Ew_I();
void ADC_Ed_I();
void SBB_Eb_Gb();
void SBB_Ew_Gw();
void SBB_Ed_Gd();
void SBB_Gb_Eb();
void SBB_Gw_Ew();
void SBB_Gd_Ed();
void SBB_AL_Ib();
void SBB_AX_Iw();
void SBB_EAX_Id();
void SBB_Eb_I();
void SBB_Ew_I();
void SBB_Ed_I();
void AND_Eb_Gb();
void AND_Ew_Gw();
void AND_Ed_Gd();
void AND_Gb_Eb();
void AND_Gw_Ew();
void AND_Gd_Ed();
void AND_AL_Ib();
void AND_AX_Iw();
void AND_EAX_Id();
void AND_Eb_I();
void AND_Ew_I();
void AND_Ed_I();
void SUB_Eb_Gb();
void SUB_Ew_Gw();
void SUB_Ed_Gd();
void SUB_Gb_Eb();
void SUB_Gw_Ew();
void SUB_Gd_Ed();
void SUB_AL_Ib();
void SUB_AX_Iw();
void SUB_EAX_Id();
void SUB_Eb_I();
void SUB_Ew_I();
void SUB_Ed_I();
void XOR_Eb_Gb();
void XOR_Ew_Gw();
void XOR_Ed_Gd();
void XOR_Gb_Eb();
void XOR_Gw_Ew();
void XOR_Gd_Ed();
void XOR_AL_Ib();
void XOR_AX_Iw();
void XOR_EAX_Id();
void XOR_Eb_I();
void XOR_Ew_I();
void XOR_Ed_I();
void CMP_Eb_Gb();
void CMP_Ew_Gw();
void CMP_Ed_Gd();
void CMP_Gb_Eb();
void CMP_Gw_Ew();
void CMP_Gd_Ed();
void CMP_AL_Ib();
void CMP_AX_Iw();
void CMP_EAX_Id();
void CMP_Eb_I();
void CMP_Ew_I();
void CMP_Ed_I();
void TEST_Eb_Gb();
void TEST_Ew_Gw();
void TEST_Ed_Gd();
void TEST_AL_Ib();
void TEST_AX_Iw();
void TEST_EAX_Id();
void TEST_Eb_I();
void TEST_Ew_I();
void TEST_Ed_I();
void INC_AX();
void INC_CX();
void INC_DX();
void INC_BX();
void INC_SP();
void INC_BP();
void INC_SI();
void INC_DI();
void INC_EAX();
void INC_ECX();
void INC_EDX();
void INC_EBX();
void INC_ESP();
void INC_EBP();
void INC_ESI();
void INC_EDI();
void INC_Eb();
void INC_Ew();
void INC_Ed();
void DEC_AX();
void DEC_CX();
void DEC_DX();
void DEC_BX();
void DEC_SP();
void DEC_BP();
void DEC_SI();
void DEC_DI();
void DEC_EAX();
void DEC_ECX();
void DEC_EDX();
void DEC_EBX();
void DEC_ESP();
void DEC_EBP();
void DEC_ESI();
void DEC_EDI();
void DEC_Eb();
void DEC_Ew();
void DEC_Ed();
void NOT_Eb();
void NOT_Ew();
void NOT_Ed();
void NEG_Eb();
void NEG_Ew();
void NEG_Ed();
void CMOVO_Gw_Ew();
void CMOVO_Gd_Ed();
void CMOVNO_Gw_Ew();
void CMOVNO_Gd_Ed();
void CMOVB_Gw_Ew();
void CMOVB_Gd_Ed();
void CMOVAE_Gw_Ew();
void CMOVAE_Gd_Ed();
void CMOVE_Gw_Ew();
void CMOVE_Gd_Ed();
void CMOVNE_Gw_Ew();
void CMOVNE_Gd_Ed();
void CMOVBE_Gw_Ew();
void CMOVBE_Gd_Ed();
void CMOVA_Gw_Ew();
void CMOVA_Gd_Ed();
void CMOVS_Gw_Ew();
void CMOVS_Gd_Ed();
void CMOVNS_Gw_Ew();
void CMOVNS_Gd_Ed();
void CMOVP_Gw_Ew();
void CMOVP_Gd_Ed();
void CMOVNP_Gw_Ew();
void CMOVNP_Gd_Ed();
void CMOVL_Gw_Ew();
void CMOVL_Gd_Ed();
void CMOVNL_Gw_Ew();
void CMOVNL_Gd_Ed();
void CMOVLE_Gw_Ew();
void CMOVLE_Gd_Ed();
void CMOVNLE_Gw_Ew();
void CMOVNLE_Gd_Ed();
void SETO_Eb();
void SETNO_Eb();
void SETB_Eb();
void SETAE_Eb();
void SETE_Eb();
void SETNE_Eb();
void SETBE_Eb();
void SETA_Eb();
void SETS_Eb();
void SETNS_Eb();
void SETP_Eb();
void SETNP_Eb();
void SETL_Eb();
void SETNL_Eb();
void SETLE_Eb();
void SETNLE_Eb();
void MOV_AL_Ib();
void MOV_CL_Ib();
void MOV_DL_Ib();
void MOV_BL_Ib();
void MOV_AH_Ib();
void MOV_CH_Ib();
void MOV_DH_Ib();
void MOV_BH_Ib();
void MOV_AX_Iw();
void MOV_CX_Iw();
void MOV_DX_Iw();
void MOV_BX_Iw();
void MOV_SP_Iw();
void MOV_BP_Iw();
void MOV_SI_Iw();
void MOV_DI_Iw();
void MOV_EAX_Id();
void MOV_ECX_Id();
void MOV_EDX_Id();
void MOV_EBX_Id();
void MOV_ESP_Id();
void MOV_EBP_Id();
void MOV_ESI_Id();
void MOV_EDI_Id();
void MOV_Eb_Gb();
void MOV_Ew_Gw();
void MOV_Ed_Gd();
void MOV_Gb_Eb();
void MOV_Gw_Ew();
void MOV_Gd_Ed();
void MOV_Eb_Ib();
void MOV_Ew_Iw();
void MOV_Ed_Id();
void MOVZX_Gw_Eb();
void MOVZX_Gd_Eb();
void MOVZX_Gd_Ew();
void MOVSX_Gw_Eb();
void MOVSX_Gd_Eb();
void MOVSX_Gd_Ew();
void CBW();
void CWDE();
void CWD();
void CDQ();
void BSWAP_EAX();
void BSWAP_ECX();
void BSWAP_EDX();
void BSWAP_EBX();
void BSWAP_ESP();
void BSWAP_EBP();
void BSWAP_ESI();
void BSWAP_EDI();
void NOP();
void XCHG_CX();
void XCHG_DX();
void XCHG_BX();
void XCHG_SP();
void XCHG_BP();
void XCHG_SI();
void XCHG_DI();
void XCHG_ECX();
void XCHG_EDX();
void XCHG_EBX();
void XCHG_ESP();
void XCHG_EBP();
void XCHG_ESI();
void XCHG_EDI();
void XCHG_Eb_Gb();
void XCHG_Ew_Gw();
void XCHG_Ed_Gd();
void XADD_Eb_Gb();
void XADD_Ew_Gw();
void XADD_Ed_Gd();
void CMPXCHG_Eb_Gb();
void CMPXCHG_Ew_Gw();
void CMPXCHG_Ed_Gd();
void ROL_Eb_Ib();
void ROR_Eb_Ib();
void RCL_Eb_Ib();
void RCR_Eb_Ib();
void SHL_Eb_Ib();
void SHR_Eb_Ib();
void SAR_Eb_Ib();
void ROL_Eb_1();
void ROR_Eb_1();
void RCL_Eb_1();
void RCR_Eb_1();
void SHL_Eb_1();
void SHR_Eb_1();
void SAR_Eb_1();
void ROL_Eb_CL();
void ROR_Eb_CL();
void RCL_Eb_CL();
void RCR_Eb_CL();
void SHL_Eb_CL();
void SHR_Eb_CL();
void SAR_Eb_CL();
void ROL_Ew_Ib();
void ROR_Ew_Ib();
void RCL_Ew_Ib();
void RCR_Ew_Ib();
void SHL_Ew_Ib();
void SHR_Ew_Ib();
void SAR_Ew_Ib();
void ROL_Ew_1();
void ROR_Ew_1();
void RCL_Ew_1();
void RCR_Ew_1();
void SHL_Ew_1();
void SHR_Ew_1();
void SAR_Ew_1();
void ROL_Ew_CL();
void ROR_Ew_CL();
void RCL_Ew_CL();
void RCR_Ew_CL();
void SHL_Ew_CL();
void SHR_Ew_CL();
void SAR_Ew_CL();
void ROL_Ed_Ib();
void ROR_Ed_Ib();
void RCL_Ed_Ib();
void RCR_Ed_Ib();
void SHL_Ed_Ib();
void SHR_Ed_Ib();
void SAR_Ed_Ib();
void ROL_Ed_1();
void ROR_Ed_1();
void RCL_Ed_1();
void RCR_Ed_1();
void SHL_Ed_1();
void SHR_Ed_1();
void SAR_Ed_1();
void ROL_Ed_CL();
void ROR_Ed_CL();
void RCL_Ed_CL();
void RCR_Ed_CL();
void SHL_Ed_CL();
void SHR_Ed_CL();
void SAR_Ed_CL();
void SHLD_Ew_Gw_Ib();
void SHLD_Ew_Gw_CL();
void SHRD_Ew_Gw_Ib();
void SHRD_Ew_Gw_CL();
void SHLD_Ed_Gd_Ib();
void SHLD_Ed_Gd_CL();
void SHRD_Ed_Gd_Ib();
void SHRD_Ed_Gd_CL();
void MOVSB();
void MOVSW();
void MOVSD();
void CMPSB();
void CMPSW();
void CMPSD();
void STOSB();
void STOSW();
void STOSD();
void LODSB();
void LODSW();
void LODSD();
void SCASB();
void SCASW();
void SCASD();
void BSF_Gw_Ew();
void BSF_Gd_Ed();
void BSR_Gw_Ew();
void BSR_Gd_Ed();
void DAA();
void DAS();
void AAA();
void AAS();
void AAM_Ib();
void AAD_Ib();
void MOV_AL_Ob();
void MOV_AX_Ow();
void MOV_EAX_Od();
void MOV_Ob_AL();
void MOV_Ow_AX();
void MOV_Od_EAX();
void MOV_Ew_Sw();
void MOV_Sw_Ew();
void XLAT();
void MUL_Eb();
void MUL_Ew();
void MUL_Ed();
void IMUL_Eb();
void IMUL_Ew();
void IMUL_Ed();
void IMUL_Gw_Ew();
void IMUL_Gd_Ed();
void IMUL_Gw_Ew_I();
void IMUL_Gd_Ed_I();
void DIV_Eb();
void DIV_Ew();
void DIV_Ed();
void IDIV_Eb();
void IDIV_Ew();
void IDIV_Ed();
void PUSH_CSw();
void PUSH_CSd();
void PUSH_DSw();
void PUSH_DSd();
void PUSH_ESw();
void PUSH_ESd();
void PUSH_FSw();
void PUSH_FSd();
void PUSH_GSw();
void PUSH_GSd();
void PUSH_SSw();
void PUSH_SSd();
void POP_DSw();
void POP_DSd();
void POP_ESw();
void POP_ESd();
void POP_FSw();
void POP_FSd();
void POP_GSw();
void POP_GSd();
void POP_SSw();
void POP_SSd();
void PUSH_AX();
void PUSH_EAX();
void PUSH_CX();
void PUSH_ECX();
void PUSH_DX();
void PUSH_EDX();
void PUSH_BX();
void PUSH_EBX();
void PUSH_SP();
void PUSH_ESP();
void PUSH_BP();
void PUSH_EBP();
void PUSH_SI();
void PUSH_ESI();
void PUSH_DI();
void PUSH_EDI();
void POP_AX();
void POP_EAX();
void POP_CX();
void POP_ECX();
void POP_DX();
void POP_EDX();
void POP_BX();
void POP_EBX();
void POP_SP();
void POP_ESP();
void POP_BP();
void POP_EBP();
void POP_SI();
void POP_ESI();
void POP_DI();
void POP_EDI();
void PUSH_Iw();
void PUSH_Id();
void PUSH_Ew();
void PUSH_Ed();
void LDS_Gw_Mp();
void LES_Gw_Mp();
void LFS_Gw_Mp();
void LGS_Gw_Mp();
void LSS_Gw_Mp();
void LDS_Gd_Mp();
void LES_Gd_Mp();
void LFS_Gd_Mp();
void LGS_Gd_Mp();
void LSS_Gd_Mp();
void BOUND_Gw_Ma();
void BOUND_Gd_Ma();
void LEA_Gw_M();
void LEA_Gd_M();
void LEAVE();
void LEAVED();

void PUSHA();
void PUSHAD();
void POPA();
void POPAD();
void POP_Ew();
void POP_Ed();
void PUSHF();
void PUSHFD();
void POPF();
void POPFD();
void ENTER_Iw_Ib();
void ARPL_Ew_Gw();
void BT_Ew_Gw();
void BT_Ed_Gd();
void BTS_Ew_Gw();
void BTS_Ed_Gd();
void BTR_Ew_Gw();
void BTR_Ed_Gd();
void BTC_Ew_Gw();
void BTC_Ed_Gd();
void BT_Ew_Ib();
void BT_Ed_Ib();
void BTS_Ew_Ib();
void BTS_Ed_Ib();
void BTR_Ew_Ib();
void BTR_Ed_Ib();
void BTC_Ew_Ib();
void BTC_Ed_Ib();
void CMPXCH8B_Mq();

// from ctrlflow.cpp
void JO_Jd();
void JNO_Jd();
void JB_Jd();
void JNB_Jd();
void JE_Jd();
void JNE_Jd();
void JBE_Jd();
void JNBE_Jd();
void JS_Jd();
void JNS_Jd();
void JP_Jd();
void JNP_Jd();
void JL_Jd();
void JNL_Jd();
void JLE_Jd();
void JNLE_Jd();
void JO_Jw();
void JNO_Jw();
void JB_Jw();
void JNB_Jw();
void JE_Jw();
void JNE_Jw();
void JBE_Jw();
void JNBE_Jw();
void JS_Jw();
void JNS_Jw();
void JP_Jw();
void JNP_Jw();
void JL_Jw();
void JNL_Jw();
void JLE_Jw();
void JNLE_Jw();
void JCXZ();
void JECXZ();
void LOOP();
void LOOPD();
void LOOPE();
void LOOPDE();
void LOOPNE();
void LOOPDNE();
void JMPN_Jw();
void JMPN_Jd();
void JMPN_Ew();
void JMPN_Ed();
void CALLN_Jw();
void CALLN_Jd();
void CALLN_Ew();
void CALLN_Ed();

void CALLF_w_w();
void CALLF_d_w();
void RETN_Iw();
void RETND_Iw();
void RETN();
void RETND();
void RETF_Iw();
void RETF();
void IRET();
void IRETD();
void JMPf_APw();
void JMPf_APd();
void CALLF_Ep();
void JMPF_Ep();

// from flags.cpp
void CMC();
void CLC();
void STC();
void SALC();
void SAHF();
void LAHF();
void CLD();
void STD();

// from system.cpp
void CPUID();

void INSB();
void INSW();
void INSD();
void OUTSB();
void OUTSW();
void OUTSD();
void IN_AL_Ib();
void IN_AX_Ib();
void IN_EAX_Ib();
void OUT_Ib_AL();
void OUT_Ib_AX();
void OUT_Ib_EAX();
void IN_AL_DX();
void IN_AX_DX();
void IN_EAX_DX();
void OUT_DX_AL();
void OUT_DX_AX();
void OUT_DX_EAX();
void INT_3();
void INT_Ib();
void INTO();
void INT1();
void HLT();
void CLI();
void STI();
void LAR_Gw_Ew();
void LAR_Gd_Ew();
void LSL_Gw_Ew();
void LSL_Gd_Ew();
#if !CFG_AMDEXT
void LOADALL();
#else
void SYSCALL();
void SYSRET();
#endif
void CLTS();
void INVD();
void WBINVD();
void MOV_Rd_Cd();
void MOV_Cd_Rd();
void MOV_Rd_Dd();
void MOV_Dd_Rd();
void MOV_Rd_Td();
void MOV_Td_Rd();
void WRMSR();
void RDMSR();
void RDTSC();
void RDPMC();
void SYSENTER();
void SYSEXIT();
void RSM();
void SLDT_Ew();
void STR_Ew();
void LLDT_Ew();
void LTR_Ew();
void VERR_Ew();
void VERW_Ew();
void SGDT_Ms();
void SIDT_Ms();
void LGDT_Ms();
void LIDT_Ms();
void SMSW_Ew();
void LMSW_Ew();
void INVLPG_Mb();
void MONITOR();
void CLFLUSH();
void FXSAVE();
void FXRSTOR();
void LFENCE();
void MFENCE();
void SFENCE();

// from fpu.cpp
void FWAIT();
void FADD_m32();
void FMUL_m32();
void FCOM_m32();
void FCOMP_m32();
void FSUB_m32();
void FSUBR_m32();
void FDIV_m32();
void FDIVR_m32();

void FADD_f();
void FMUL_f();
void FCOM_f();
void FCOMP_f();
void FSUB_f();
void FSUBR_f();
void FDIV_f();
void FDIVR_f();

void FLD_m32();
void FST_m32();
void FSTP_m32();
void FLDENV();
void FLDCW();
void FSTENV();
void FSTCW();

void FLD_f();
void FXCH_f();
void FNOP();
void FCHS();
void FABS();
void FTST();
void FXAM();
void FLD1();
void FLDL2T();
void FLDL2E();
void FLDPI();
void FLDLG2();
void FLDLN2();
void FLDZ();
void F2XM1();
void FYL2X();
void FPTAN();
void FPATAN();
void FXTRACT();
void FPREM1();
void FDECSTP();
void FINCSTP();
void FPREM();
void FYL2XP1();
void FSQRT();
void FSINCOS();
void FRNDINT();
void FSCALE();
void FSIN();
void FCOS();

void FIADD_m32();
void FIMUL_m32();
void FICOM_m32();
void FICOMP_m32();
void FISUB_m32();
void FISUBR_m32();
void FIDIV_m32();
void FIDIVR_m32();

void FCMOVB();
void FCMOVE();
void FCMOVBE();
void FCMOVU();
void FUCOMPP();

void FILD_m32();
void FIST_m32();
void FISTP_m32();
void FLD_m80();
void FSTP_m80();

void FCMOVNB();
void FCMOVNE();
void FCMOVNBE();
void FCMOVNU();
void FCLEX();
void FINIT();
void FUCOMI();
void FCOMI();

void FADD_m64();
void FMUL_m64();
void FCOM_m64();
void FCOMP_m64();
void FSUB_m64();
void FSUBR_m64();
void FDIV_m64();
void FDIVR_m64();

void FADD_r();
void FMUL_r();
void FSUB_r();
void FSUBR_r();
void FDIV_r();
void FDIVR_r();

void FLD_m64();
void FST_m64();
void FSTP_m64();
void FRSTOR();
void FSAVE();
void FSTSW_m16();

void FFREE_f();
void FST_f();
void FSTP_f();
void FUCOM_f();
void FUCOMP_f();

void FIADD_m16();
void FIMUL_m16();
void FICOM_m16();
void FICOMP_m16();
void FISUB_m16();
void FISUBR_m16();
void FIDIV_m16();
void FIDIVR_m16();

void FADDP_r();
void FMULP_r();
void FCOMPP();
void FSUBP_r();
void FSUBRP_r();
void FDIVP_r();
void FDIVRP_r();

void FILD_m16();
void FIST_m16();
void FISTP_m16();
void FBLD();
void FILD_m64();
void FBSTP();
void FISTP_m64();

void FFREEP();

void FSTSW();
void FUCOMIP();
void FCOMIP();

// from sse.cpp
void LDMXCSR();
void STMXCSR();

//
// atomic ops - pain in the rear to simulate faithfully, typically requiring custom implementation in native code
//

void LockInvalid();
void LockAddB();
void LockAddH();
void LockAddW();
void LockAdcB();
void LockAdcH();
void LockAdcW();
void LockAndB();
void LockAndH();
void LockAndW();
void LockBtcH();
void LockBtcW();
void LockBtrH();
void LockBtrW();
void LockBtsH();
void LockBtsW();
void LockCmpXchgB();
void LockCmpXchgH();
void LockCmpXchgW();
void LockCmpXchgD();
void LockDecB();
void LockDecH();
void LockDecW();
void LockIncB();
void LockIncH();
void LockIncW();
void LockNegB();
void LockNegH();
void LockNegW();
void LockNotB();
void LockNotH();
void LockNotW();
void LockOrB();
void LockOrH();
void LockOrW();
void LockSbbB();
void LockSbbH();
void LockSbbW();
void LockSubB();
void LockSubH();
void LockSubW();
void LockXorB();
void LockXorH();
void LockXorW();
void LockXaddB();
void LockXaddH();
void LockXaddW();
void LockXchgB();
void LockXchgH();
void LockXchgW();

#ifdef WITH_PIN_SUPPORT
void MOVQ_XMM_ECX();
void MOVQ_ECX_XMM();
void MOVQ_XMM_IMM();
#endif  // WITH_PIN_SUPPORT

#endif
